#include "CCalTemp.h"

// Version	V1.5 2024-12-10

#define     OPENMODE_TEMP_DIFF_THRED         0.2//0.15               //判断打开手臂下的温度阈值
#define     LEADOFF_TEMP_LOW_THRED           30.0               //判断体温计脱落的最低温度值
#define     REAL_TEMP_LOW_TEMP               35.0   
#define     TOTAL_REACH_TEMP_MIN_CNT         6					//判断闭合条件下的连续满足条件的分钟数
#define     OPEN_MODE_MIN_SIZE               10                 //用于修正手臂打开条件的数据队列长度，对应着分钟数
//float		temp_coeff_buf[OPEN_MODE_MIN_SIZE][2];              //用于存储温度差和温度降幅的缓冲
//#define		TRUE true
//#define		FALSE false
#define		FIRST_STABLE_SUSTAIN_TIME		(60 * 5)			//闭合条件下满足首次稳定的持续时长，单位秒
#define		AFTER_SUSTAIN_TIME				(60 * 15)			//腋下闭合的持续时间

// 全局变量
char leadoffflag = true;
char lastleadoffflag = true;
char openmodeflag = true;					//脱落标志，打开标志
float realtemp = 0.0f, lastnoleadofftemp = 0.0f;        //真实温度值、上次非脱落情况下的真实温度值
float openmodeCoff = 0.0f;									//打开状态下的系数
long SecCnt = 0, MinCnt = 0;               //根据计算次数调用时间计数
int tempreachMinCnt = 0, totalMinCnt = 0;
char tempsteadyflag = false;               //温度稳定的标志
int openmodeMinCnt = 0, totalopenmodeMinCnt = 0;    //手臂打开条件下的计时标志
char firstbufffullflag = false;            //系数缓冲队列队列首次填满的标志
float lastleadofftemp = 0.0f, totaltempdiff = 0.0f, totaltempdec = 0.0f;

long firstStableSustain = 0;				// 首次体温稳定持续时长
long afterCloseSustain = 0;					// 腋下闭合持续时间
float beforeOpenTemp = 0.0;					// 腋下打开前的有效体温
float macroCorrectionTemp = 0.0;			// 体温宏观修正值
float fixTemp = 0.0;						// 腋下打开后的修复后的体温
float fixKeepTemp = 0.0;						// 最后修复时显示的值

#define		Data_INTERVAL_TIME				(2)					//数据间隔2秒
#define		COLLECT_DATA_SIZE				(30 * 4)			//对应2秒 (30 * 4)
float		temp_collect_data_buf[COLLECT_DATA_SIZE][4];		//用于记录采集到的环境温度、体表温、温差、温度变化值
int temp_collect_data_index = 0;
bool temp_collect_data_full = false;		//buff是否缓存满了
long afterOpenSustain = 0;					// 腋下打开持续时间
long afterOpenTime = 0;						// 腋下打开的绝对时间
#define		OpenSustainCheckTime			(COLLECT_DATA_SIZE * Data_INTERVAL_TIME)			// 腋下持续打开后数据稳定性判定检测时长
#define		TEMP_STABILITY_RANGE			(0.3f)				//温度稳定的判定标准，偏差±0.3℃
bool hasCalcTempFactor = false;				//已经计算了温变系数
bool hasCalcTempFactorLast = false;			//已经计算了温变系数，上一次的状态
float tempFactorNum = -1;					//温变系数（应用于计算的）
float realTempFactorNum = -1;				//实时温变系数
float avgTemp = 0.0f;						//用于记录温度稳定时的均值
float tempChangeConstant = 0.0f;			//温度变化常数
float afterOpenStableTempBaseLine = 0.0f;	//打开胳膊后的体温稳定基线
bool afterOpenTempIsStable = false;			//打开胳膊后体温是稳定的
float realMicroCorrectTemp = -1;			//实时微观修正值

bool debugFlagUseTempFactor = false;		// 是否用闻变系数更新温度
bool tempDiffChangeJumpFlag = false;		// 温差稳定后发生了突变
int tempDiffChangeJumpCnt = 0;				// 温差突变的不应期

uint8_t dataInputIndex = 0;
bool globalSensorOff = false;				//全局记录当前是否发生了脱落


void initCache() {
	leadoffflag = true;
	lastleadoffflag = true;
	openmodeflag = true;					//脱落标志，打开标志
	realtemp = 0.0f, lastnoleadofftemp = 0.0f;        //真实温度值、上次非脱落情况下的真实温度值
	openmodeCoff = 0.0f;									//打开状态下的系数
	SecCnt = 0, MinCnt = 0;               //根据计算次数调用时间计数	
	tempreachMinCnt = 0, totalMinCnt = 0;
	tempsteadyflag = false;               //温度稳定的标志
	openmodeMinCnt = 0, totalopenmodeMinCnt = 0;    //手臂打开条件下的计时标志
	//firstbufffullflag = false;            //系数缓冲队列队列首次填满的标志
	lastleadofftemp = 0.0f, totaltempdiff = 0.0f, totaltempdec = 0.0f;
	//memset(temp_coeff_buf, 0, sizeof(temp_coeff_buf));

	firstStableSustain = 0;
	afterCloseSustain = 0;
	beforeOpenTemp = 0.0;
	macroCorrectionTemp = 0.0;
	fixTemp = 0.0;
	fixKeepTemp = 0.0;

	//memset(temp_collect_data_buf, 0, sizeof(temp_collect_data_buf));
	//temp_collect_data_index = 0;
	temp_collect_data_full = false;
	afterOpenSustain = 0;
	afterOpenTime = 0;
	hasCalcTempFactor = false;
	hasCalcTempFactorLast = false;
	tempFactorNum = -1;
	realTempFactorNum = -1;
	avgTemp = 0.0f;
	tempChangeConstant = 0.0f;
	afterOpenStableTempBaseLine = 0.0f;
	afterOpenTempIsStable = false;
	realMicroCorrectTemp = -1;			//实时微观修正值
	debugFlagUseTempFactor = false;		// 是否用闻变系数更新温度
	tempDiffChangeJumpFlag = false;		// 温差稳定后发生了突变
	tempDiffChangeJumpCnt = 0;				// 温差突变的不应期
	dataInputIndex = 0;
	globalSensorOff = false;
}

/*
 * 判断温度在一段时间内体温是否发生超过指定温度的变化
 *		times：时长，秒
 *		tempChange：温度变化量，摄氏度
 */
bool checkTempChange(int times, float tempChange) {
	if (!temp_collect_data_full) {
		return false;
	}

	int loop = times / Data_INTERVAL_TIME;
	int i = 0;
	float limitTemp = tempChange;// OPENMODE_TEMP_DIFF_THRED;
	int beforeIndex = (temp_collect_data_index + COLLECT_DATA_SIZE - loop) % COLLECT_DATA_SIZE;
	if (((temp_collect_data_buf[beforeIndex][0] - temp_collect_data_buf[temp_collect_data_index][0]) > limitTemp)
		|| ((temp_collect_data_buf[beforeIndex][1] - temp_collect_data_buf[temp_collect_data_index][1]) > limitTemp)) {
		return true;
	}

	return false;
}

/*
 * 判断温度在一段时间内是否发生突然下降超过1摄氏度
 * 当前以20秒下降超过1℃为判定条件
 *		如果脱落了，返回true
 *		如果未脱落，返回false
 */
bool checkSensorOffByTempChange() {
	return checkTempChange(20, 1.0f);
}

/*
 * 判断体温探头是否低于某个阈值，确认探头是否从身体拿下来
 *		如果脱落了，返回true
 *		如果未脱落，返回false
 */
bool checkSensorOffByVal(float surfTemp, float envTemp) {
	if ((surfTemp < LEADOFF_TEMP_LOW_THRED) || (envTemp < LEADOFF_TEMP_LOW_THRED)) {
		return true;
	}
	return false;
}

/*
 * 判断体温探头是否是低温脱落脱落
 *		如果脱落了，调整状态机进入首次体温未稳定状态
 *		如果未脱落，继续原状态机执行
 */
void checkSensorOff(float surfTemp, float envTemp) {
	bool sensorOffFlag = checkSensorOffByTempChange();
	if (checkSensorOffByVal(surfTemp, envTemp) || sensorOffFlag) {
		initCache();
		
	}
	if (sensorOffFlag) {
		globalSensorOff = true;
		firstbufffullflag = false;            //系数缓冲队列队列首次填满的标志
		memset(temp_collect_data_buf, 0, sizeof(temp_collect_data_buf));
		temp_collect_data_index = 0;
	}
	else {
		globalSensorOff = false;
	}
}

/*
 *	获取缓冲体表温均值
 *		type:
 *			0:体表温均值
 *			1:环境温均值
 */
//float getTempAvg(int type) {
//	int i = 0;
//	int dataIndex = temp_collect_data_index;
//	float sum = 0;
//	for (i = 0; i < COLLECT_DATA_SIZE; i++) {
//		dataIndex %= COLLECT_DATA_SIZE;
//		if (type == 0) {
//			sum += temp_collect_data_buf[dataIndex][0];
//		}
//		else {
//			sum += temp_collect_data_buf[dataIndex][1];
//		}
//		dataIndex++;
//	}
//
//	float tempAvg = sum / COLLECT_DATA_SIZE;
//	return tempAvg;
//}

/*
 *	判断最近采集的一段时间的体表温是稳定的
 *	判定标准是体表温和环境温数据在其均值上下偏差0.15摄氏度
 */
//bool chectCurTempIsStable() {
//	bool isStable = false;
//	if (!temp_collect_data_full) {
//		return isStable;
//	}
//
//	int i = 0;
//	isStable = true;
//	int dataIndex = temp_collect_data_index;
//	float surfTempAvg = getTempAvg(0);
//	float envTempAvg = getTempAvg(1);
//
//	for (i = 0; i < COLLECT_DATA_SIZE; i++) {
//		dataIndex %= COLLECT_DATA_SIZE;
//		if (fabs(temp_collect_data_buf[dataIndex][0] - surfTempAvg) > (TEMP_STABILITY_RANGE / 2)
//			|| fabs(temp_collect_data_buf[dataIndex][1] - envTempAvg) > (TEMP_STABILITY_RANGE / 2)) {
//			isStable = false;
//			break;
//		}
//		dataIndex++;
//	}
//	if (isStable) {
//		avgTemp = surfTempAvg;
//	}
//	else {
//		avgTemp = 0.0f;
//	}
//	return isStable;
//}

/*
 *	判断最近采集的一段时间的体表温是稳定的
 *	判定标准是体表温和环境温数据在相隔3min的温变小于0.3℃
 */
bool chectCurTempIsStableEx() {
	bool isStable = false;
	if (!temp_collect_data_full) {
		return isStable;
	}

	int i = 0;
	isStable = true;
	int dataIndex = temp_collect_data_index + 1;
	//int baseLen = 60 / Data_INTERVAL_TIME;
	int baseLen = 3 * 60 / Data_INTERVAL_TIME;
	int nextMinIndex = dataIndex;
	for (i = 0; i < COLLECT_DATA_SIZE - baseLen; i++) {
		dataIndex %= COLLECT_DATA_SIZE;
		nextMinIndex = (dataIndex + baseLen) % COLLECT_DATA_SIZE;
		if ((fabs(temp_collect_data_buf[nextMinIndex][0] - temp_collect_data_buf[dataIndex][0]) > TEMP_STABILITY_RANGE)
			|| (fabs(temp_collect_data_buf[nextMinIndex][1] - temp_collect_data_buf[dataIndex][1]) > TEMP_STABILITY_RANGE)) {
			isStable = false;
			break;
		}
		dataIndex++;
	}
	return isStable;
}

/*
 *	判断最近采集的一段时间的温差是稳定的
 *	判定标准是最近3min体表温和环境温数据的温差均值与当前温差的变化不超过?%
 *		目前标准：23%
 */
bool chectTempDiffIsStable() {
	bool isStable = false;
	if (!temp_collect_data_full) {
		return isStable;
	}

	int i = 0;
	int baseLen = 3 * 60 / Data_INTERVAL_TIME;
	int dealLen = baseLen * 0.8;
	int dataIndexStart = (temp_collect_data_index + COLLECT_DATA_SIZE - baseLen) % COLLECT_DATA_SIZE;
	int dataIndexEnd = dataIndexStart + dealLen;
	double sumTemp = 0.0;
	int curIndex = dataIndexStart;
	for (i = 0; i < dealLen; i++) {
		sumTemp += temp_collect_data_buf[curIndex][2];
		curIndex++;
		curIndex %= COLLECT_DATA_SIZE;
	}
	float avgTemp = sumTemp / dealLen;

	float rate = 0;
	if (avgTemp != 0) {
		rate = fabs(temp_collect_data_buf[temp_collect_data_index][2] - avgTemp) / avgTemp;
	}
	//printf("rate is %f\r\n", rate);
	if (rate < 0.23f) {//0.13f
		isStable = true;
	}
	return isStable;
}

/*
*	获取最近一段时间的体温最大值
*	params:
*		time:最近持续时长，秒
*		surfTemp:当前体表温
*/
float getTempMaxLastes(int time, float surfTemp) {
	if (!temp_collect_data_full) {
		return surfTemp;
	}

	int loop = time / Data_INTERVAL_TIME;
	int i = 0;
	int curIndex = (temp_collect_data_index + COLLECT_DATA_SIZE - loop) % COLLECT_DATA_SIZE;
	float maxTemp = surfTemp;
	for (i = 0; i < loop; i++) {
		if (maxTemp < temp_collect_data_buf[curIndex][0]) {
			maxTemp = temp_collect_data_buf[curIndex][0];
		}
		curIndex++;
		curIndex %= COLLECT_DATA_SIZE;
	}
	return maxTemp;
}

/*
 *	根据缓冲计算一次温变系数
 */
float calcTempFactor() {
	int i = 0;
	int dataIndex = temp_collect_data_index;
	//tempChangeConstant = beforeOpenTemp - (avgTemp + TEMP_STABILITY_RANGE / 2);
	tempChangeConstant = beforeOpenTemp - avgTemp;
	//tempChangeConstant = beforeOpenTemp - (avgTemp - (TEMP_STABILITY_RANGE / 2));
	afterOpenStableTempBaseLine = beforeOpenTemp - tempChangeConstant;
	float sumTempChange = 0.0f;
	float sumTempDiff = 0.0f;

	for (i = 0; i < COLLECT_DATA_SIZE; i++) {
		dataIndex %= COLLECT_DATA_SIZE;
		//sumTempChange += (afterOpenStableTempBaseLine - temp_collect_data_buf[dataIndex][0]);
		sumTempChange += temp_collect_data_buf[dataIndex][3];
		sumTempDiff += temp_collect_data_buf[dataIndex][2];
		dataIndex++;
	}
	if (sumTempDiff == 0)
		return 0;

	float tmpTempFactorNum = sumTempChange / sumTempDiff;


	/*
	//更新数组中的温变信息
	i = 0;
	dataIndex = temp_collect_data_index;
	int nextIndex = 0;
	for (i = 0; i < COLLECT_DATA_SIZE; i++) {
		dataIndex %= COLLECT_DATA_SIZE;
		// 第一版使用基线温度与体表温的差
		//temp_collect_data_buf[dataIndex][3] = afterOpenStableTempBaseLine - temp_collect_data_buf[dataIndex][0];
		// 第二版使用体表温的变化量的绝对值
		if (i == 0) {
			temp_collect_data_buf[dataIndex][3] = 0;
		}
		else {
			nextIndex = dataIndex + 1;
			nextIndex %= COLLECT_DATA_SIZE;
			//temp_collect_data_buf[dataIndex][3] = fabs(temp_collect_data_buf[nextIndex][0] - temp_collect_data_buf[dataIndex][0]);
			temp_collect_data_buf[dataIndex][3] = temp_collect_data_buf[nextIndex][0] - temp_collect_data_buf[dataIndex][0];
		}
		dataIndex++;
	}
	*/
	return tmpTempFactorNum;
}

/*
 *	根据温变系数和当前体表温、环境温度推算核心体温
 */
float calcTempByTempFactor(float surfTemp, float envTemp) {
	float fixTemp = 0.0f;
	float tempDiff = surfTemp - envTemp;
	int i = 0;
	int dataIndex = temp_collect_data_index;
	float sumTempChange = 0.0f;	// 温变和
	float sumTempDiff = 0.0f;	// 温差和
	for (i = 0; i < COLLECT_DATA_SIZE; i++) {
		dataIndex %= COLLECT_DATA_SIZE;
		sumTempDiff += temp_collect_data_buf[dataIndex][2];
		if (i != 0) {
			sumTempChange += temp_collect_data_buf[dataIndex][3];
		}
		dataIndex++;
	}

	if (tempFactorNum == 0) {
		fixTemp = surfTemp;
		return fixTemp;
	}

	// 计算微观体温修正值
	float microCorrectTemp = tempFactorNum * sumTempDiff - sumTempChange;	// 第一版
	//float microCorrectTemp = tempFactorNum * temp_collect_data_buf[temp_collect_data_index][2];	// 第二版
	//temp_collect_data_buf[temp_collect_data_index][3] = microCorrectTemp;
	//float tempAvg = getTempAvg(0);
	//float baseLineChange = afterOpenStableTempBaseLine - tempAvg;
	//printf("推算的a: %lf, 实际的a: %lf\r\n", microCorrectTemp, afterOpenStableTempBaseLine - temp_collect_data_buf[temp_collect_data_index][0]);
	//fixTemp = surfTemp + tempChangeConstant + microCorrectTemp;
	//fixTemp = surfTemp + tempChangeConstant + microCorrectTemp + baseLineChange;
	fixTemp = beforeOpenTemp + microCorrectTemp;
	//fixTemp = macroCorrectionTemp + surfTemp + microCorrectTemp;
	realMicroCorrectTemp = microCorrectTemp;
	return fixTemp;
}

/*
 * 将两路温度按照权重不同进行整合，防止出现温度的突变
 */
float tempMerge(float temp1, float temp2) {
	//if (fabs(temp1 - temp2) > 0.5) 
		return temp1 * 0.999 + temp2 * 0.001;
	/*else if (fabs(temp1 - temp2) > 0.2)
		return temp1 * 0.8 + temp2 * 0.2;
	else
		return temp1 * 0.5 + temp2 * 0.5;*/
}

/*
 * 判断温度在一段时间内是否发生突然下降，以此判定手臂有没有打开
 * 当前以20秒下降超过0.1℃为判定条件
 */
bool checkTempSuddenChange() {
	return checkTempChange(20, 0.1f);
}

bool suspectOpen() {
	if (afterOpenSustain > 0)
		return true;
	return false;
}

/*
 * 当前是否识别出发生了探头脱落
 *		true：发生脱落
 *		false：未发生脱落
 */
bool sensorOff()
{
	return globalSensorOff;
}

TempBuffPoint getBufferCache()
{
	return temp_collect_data_buf;
}

int getBuffValidLen()
{
	if (temp_collect_data_full)
		return COLLECT_DATA_SIZE;
	else
		return temp_collect_data_index;
}

/*
 * 当前Buf的数据起始索引
 */
int getBuffStartIndex()
{
	if (temp_collect_data_full)
		return temp_collect_data_index;
	else 
		return 0;
}


/*
 * 体温补偿算法的基本原理
 *		在经历体温稳定期后，如果出现了环境温度和体表温度温差变化超过限定值，
 *		统计出一段时间内的体表温度的变化量的和a，与体表温与环境温的温差和b，得到一个变化补偿系数c
 * 注意点:
 *		方案一：
 *		1、温度开始下降的几分钟不稳定，可以尝试丢弃
 *		2、温度的震荡有可能导致差分和被抵消为0，考虑独立计算
 *		3、腋下打开稳定后，如果体表温度变化应该直接叠加，而非把变化引入到积分中
 *		方案二（当前实现）：
 *		1、当温差变化大于阈值，用旧值替代
 *
 * surfTemp:体表温度
 * envTemp:环境温度
 * interval:数据间隔（秒）
*/

float CalTemp(float surfTemp, float envTemp, int interval)
{
	interval = Data_INTERVAL_TIME;
	//dataInputIndex++;
	//if (dataInputIndex % 2 == 0) {
	//	dataInputIndex %= 2;
	//	return realtemp;
	//}
	//dataInputIndex %= 2;

	debugFlagUseTempFactor = false;

	//if (SecCnt >= 60)
	//{
	//	SecCnt -= 60;
	//	MinCnt++;
	//}
	realMicroCorrectTemp = -1;

	// 缓存最近COLLECT_DATA_SIZE*2秒的数据待用
	temp_collect_data_buf[temp_collect_data_index][0] = surfTemp;
	temp_collect_data_buf[temp_collect_data_index][1] = envTemp;
	temp_collect_data_buf[temp_collect_data_index][2] = surfTemp - envTemp;

	// 处理低温脱落
	checkSensorOff(surfTemp, envTemp);
	//按此计数模块，作为整个系统的时钟
	SecCnt += interval;

	if (SecCnt > interval) {
		int lastIndex = temp_collect_data_index - 1;
		if (lastIndex < 0)
			lastIndex = COLLECT_DATA_SIZE - 1;
		temp_collect_data_buf[temp_collect_data_index][3] = temp_collect_data_buf[lastIndex][0] - surfTemp;
	}
	

	if (tempsteadyflag == false)     //温度未稳定的情况下，快速计算温度，同时得到准确的温度值
	{
		// 温度稳定（体表温度持续保持在35℃以上且环境温度与体表温度相差小于0.15℃保持6min）
		// todo 此处没有考虑温度变化方向需要处理
		if ((surfTemp >= REAL_TEMP_LOW_TEMP) && ((surfTemp - envTemp) < OPENMODE_TEMP_DIFF_THRED))     //体温超过最低限开始对闭合情况进行判断
		{
			firstStableSustain += interval;

			if (firstStableSustain >= FIRST_STABLE_SUSTAIN_TIME)      //满足真实温度的条件
			{
				realtemp = surfTemp;
				tempsteadyflag = true;
				afterCloseSustain = firstStableSustain;
				beforeOpenTemp = surfTemp;
				fixTemp = surfTemp;
				firstStableSustain = 0;
			}
			else {
				realtemp = surfTemp;
			}
		}
		else {                 //未连续满足条件，要对数据清零
			firstStableSustain = 0;
			realtemp = surfTemp;
		}
	}
	else      //温度已经进入稳定状态
	{
		if (((surfTemp - envTemp) < OPENMODE_TEMP_DIFF_THRED) && (!checkTempSuddenChange()))       //手臂在闭合条件下
		{
			afterCloseSustain += interval;
			if ((afterCloseSustain < AFTER_SUSTAIN_TIME) && (afterOpenSustain > 0)) {
				if (fixTemp < surfTemp) {
					realtemp = surfTemp;
				}
				else {
					realtemp = fixTemp;
					if (fabs(fixTemp - surfTemp) > 0.05) {
						fixTemp = tempMerge(fixTemp, surfTemp);
						fixTemp = realtemp;
					}
				}
			}
			else {
				if (fixTemp < surfTemp)
					fixTemp = surfTemp;

				if ((fabs(fixTemp - surfTemp) > 0.05) && (afterOpenSustain > 0)) {
					fixTemp = tempMerge(fixTemp, surfTemp);
					realtemp = fixTemp;
					fixKeepTemp = fixTemp;
				}
				else {
					afterOpenSustain = 0;
					afterOpenTime = 0;
					realtemp = surfTemp;
					fixKeepTemp = surfTemp;
				}
					
				beforeOpenTemp = surfTemp;

				//清零手臂打开条件下的参数
				//afterOpenSustain = 0;
				hasCalcTempFactor = false;
				hasCalcTempFactorLast = false;
				tempFactorNum = -1;
				realTempFactorNum = -1;
				avgTemp = 0.0f;
				tempChangeConstant = 0;
				afterOpenStableTempBaseLine = 0.0f;
				afterOpenTempIsStable = false;
				macroCorrectionTemp = 0.0;
			}
		}
		else   //已经打开了手臂
		{
			if (afterOpenSustain == 0) {
				// 第一次判定打开了手臂,更新打开手臂前的体温为之前30秒里的最大值
				beforeOpenTemp = getTempMaxLastes(OpenSustainCheckTime, surfTemp);
				fixKeepTemp = beforeOpenTemp;
				afterOpenTime = SecCnt;
			}
			afterOpenSustain += interval;

			if (afterOpenSustain > OpenSustainCheckTime) {
				//afterOpenTempIsStable = chectCurTempIsStable();
				afterOpenTempIsStable = chectCurTempIsStableEx();
				if ((!hasCalcTempFactor) && afterOpenTempIsStable) {
					// 更新温变系数
					hasCalcTempFactor = true;
					tempFactorNum = calcTempFactor();
					realTempFactorNum = tempFactorNum;
					macroCorrectionTemp = beforeOpenTemp - surfTemp;
				}
			}

			// 清零手臂夹紧条件下的参数
			afterCloseSustain = 0;
			realTempFactorNum = calcTempFactor();

			// 手臂打开且稳定了一段时间后根据温变系数更新体温，否则还显示旧的温度值
			if (hasCalcTempFactor && hasCalcTempFactorLast && (!tempDiffChangeJumpFlag)) {
				// 判断最近三分钟温度变化是否超过了0.3℃
				bool curTempIsStable = chectCurTempIsStableEx();
				// 判断最近三分钟温差变化量是否超过稳定均值的23%
				bool diffIsStable = chectTempDiffIsStable();
				if (curTempIsStable && (!diffIsStable)) {
					// 如果温差发生了较大变化，那么保持3min,这三分钟内不进行温变系数修正,否则系数修正判断和温差稳定性逻辑会碰撞频繁切换
					//printf("-------------------------------------------------\r\n");
					tempDiffChangeJumpFlag = true;
					tempDiffChangeJumpCnt = 0;
				}
				if (curTempIsStable && diffIsStable) {
					// 根据温变系数推算核心体温	
					fixTemp = calcTempByTempFactor(surfTemp, envTemp);
					fixKeepTemp = tempMerge(fixKeepTemp, fixTemp);
					fixTemp = fixKeepTemp;
					debugFlagUseTempFactor = true;
				}
				else {
					hasCalcTempFactor = false;
					hasCalcTempFactorLast = false;
					afterOpenTempIsStable = false;
					//fixTemp = beforeOpenTemp;
					fixTemp = fixKeepTemp;
				}
			}
			else {
				if (tempDiffChangeJumpFlag) {
					if (tempDiffChangeJumpCnt == 0) {
						// 跟新下闭合前的恒定体温，将打开的温度变化累加起来
						beforeOpenTemp = fixKeepTemp;
					}
					tempDiffChangeJumpCnt++;
					if (tempDiffChangeJumpCnt > (3 * 60 / interval)) {
						tempDiffChangeJumpFlag = false;
						tempDiffChangeJumpCnt = 0;
					}
				}
				// 更新缓冲区的温变系数支持数组
				//temp_collect_data_buf[temp_collect_data_index][3] = 0;
				realTempFactorNum = -1;

				//fixTemp = beforeOpenTemp;
				fixTemp = fixKeepTemp;
				if ((fixTemp < surfTemp)) {	// && ((surfTemp - fixTemp) < 0.2)
					beforeOpenTemp = surfTemp;
					fixTemp = surfTemp;
					fixKeepTemp = fixTemp;
				}
			}

			hasCalcTempFactorLast = hasCalcTempFactor;

			realtemp = fixTemp;
		}

	}

	temp_collect_data_index++;
	if (temp_collect_data_index >= COLLECT_DATA_SIZE) {
		temp_collect_data_index = 0;
		temp_collect_data_full = true;
	}

	if (realtemp >= 45.0)
		return 45.0;
	if (realtemp <= 15.0)
		return 15.0;

	return realtemp;
}